home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / PROGRAMM / PASCAL / 0921.ZIP / MAZE.ARC / MAZE.PAS
Pascal/Delphi Source File  |  1987-11-22  |  23KB  |  678 lines
  1. PROGRAM maze(INPUT,OUTPUT);
  2. { 
  3.          This program builds a maze on your CRT.  After the maze is built,
  4.     you may use the cursor keys to solve it.  Press "Q" to quit or press
  5.     "S" to have the computer solve the maze.  If the computer solves the 
  6.     maze, you must press some key to exit.  A different random number seed
  7.     will produce a different maze.  Each maze has exactly one solution that
  8.     does not involve backtracking (passing through a doorway more than once).
  9.       
  10.         Written by James L. Dean.
  11.  
  12. }   
  13.  
  14.   CONST
  15.  
  16. {  Columns and rows in maze. } 
  17.  
  18.     max_num_columns=159;
  19.     max_num_rows=99;    
  20.  
  21. {  Color assignments. } 
  22.  
  23.     erase=2;     {  Wall must be positive     } 
  24.     wall=3;      {  Wall, passage, and path   } 
  25.     passage=0;   {  must be different.  Wall, } 
  26.     path=1;      {  path, and erase must be   } 
  27.                  {  different                 } 
  28.  
  29.   TYPE
  30.     regs = RECORD
  31.                  al    : CHAR;
  32.                  ah    : BYTE;
  33.                  bx    : INTEGER;
  34.                  cx    : INTEGER;
  35.                  dx    : INTEGER;
  36.                  bp    : INTEGER;
  37.                  si    : INTEGER;
  38.                  di    : INTEGER;
  39.                  ds    : INTEGER;
  40.                  es    : INTEGER;
  41.                  flags : INTEGER
  42.                END;
  43.   VAR
  44.     delta_x                 : ARRAY [0..3] OF ARRAY [0..23] OF INTEGER;
  45.     delta_y                 : ARRAY [0..3] OF ARRAY [0..23] OF INTEGER;
  46.     magnitude_delta_x       : INTEGER;
  47.     magnitude_delta_y       : INTEGER;
  48.     num_columns             : INTEGER;
  49.     num_rows                : INTEGER;
  50.     register                : REGS;
  51.     r_n                     : ARRAY [0..7] OF INTEGER;
  52.     r_n_index_1             : INTEGER;
  53.     r_n_index_2             : INTEGER;
  54.     screen                  : ARRAY [0..16383] OF BYTE ABSOLUTE $B800:$0000;
  55.     screen_image            : ARRAY [0..16383] OF BYTE;
  56.     tem_int                 : INTEGER;
  57.     twice_magnitude_delta_x : INTEGER;
  58.     twice_magnitude_delta_y : INTEGER;
  59.     x                       : INTEGER;
  60.     x_max                   : INTEGER;
  61.     x_next                  : INTEGER;
  62.     x_out                   : INTEGER;
  63.     y                       : INTEGER;
  64.     y_max                   : INTEGER;
  65.     y_next                  : INTEGER;
  66.     y_out                   : INTEGER;
  67.     y_out_max               : INTEGER;
  68.  
  69.  
  70.   PROCEDURE initialize; 
  71.     VAR
  72.       delta_index_1a : INTEGER;
  73.       delta_index_1b : INTEGER;
  74.       delta_index_1c : INTEGER;
  75.       delta_index_1d : INTEGER;
  76.       delta_index_2  : INTEGER;
  77.       seed           : STRING[8];
  78.       tem_int        : INTEGER;
  79.     BEGIN
  80.       ClrScr;
  81.       WRITELN(OUTPUT,'                                 Maze Generator');
  82.       WRITELN(OUTPUT,' ');
  83.       WRITELN(OUTPUT,' ');
  84.       WRITELN(OUTPUT,' ');
  85.       WRITELN(OUTPUT,
  86. '     This program will generate a maze.  After the maze is generated, you');
  87.       WRITELN(OUTPUT,
  88. 'may use the cursor keys to solve it.  Press Q to quit or S to have the');
  89.       WRITELN(OUTPUT,
  90. 'computer solve the maze.  If the computer solves the maze, you must press');
  91.       WRITELN(OUTPUT,
  92. 'some key to exit.');
  93.       WRITELN(OUTPUT,' ');
  94.       REPEAT
  95.         WRITE(OUTPUT,'     Number of columns? ');
  96.         READLN(INPUT,num_columns);
  97.         IF ((num_columns < 1) OR (num_columns > max_num_columns)) THEN
  98.           BEGIN
  99.             WRITE(OUTPUT,
  100.              '? The number of columns must be between 1 and ');
  101.             WRITE(OUTPUT,max_num_columns);
  102.             WRITELN(OUTPUT,', inclusively')
  103.           END
  104.       UNTIL ((num_columns >= 1) AND (num_columns <= max_num_columns));
  105.       WRITELN(OUTPUT,' ');
  106.       REPEAT
  107.         WRITE(OUTPUT,'     Number of rows? ');
  108.         READLN(INPUT,num_rows);
  109.         IF ((num_rows < 1) OR (num_rows > max_num_rows)) THEN
  110.           BEGIN
  111.             WRITE(OUTPUT,
  112.              '? The number of rows must be between 1 and ');
  113.             WRITE(OUTPUT,max_num_rows);
  114.             WRITELN(OUTPUT,', inclusively')
  115.           END
  116.       UNTIL ((num_rows >= 1) AND (num_rows <= max_num_rows));
  117.       WRITELN(OUTPUT,' ');
  118.       WRITE(OUTPUT,'     Random number seed? ');
  119.       READLN(INPUT,seed);
  120.       r_n_index_1:=0;
  121.       FOR r_n_index_2:=1 TO Length(seed) DO
  122.         BEGIN
  123.           tem_int:=ORD(seed[r_n_index_2]);
  124.           WHILE (tem_int >= 29) DO tem_int:=tem_int-29;
  125.           r_n[r_n_index_1]:=tem_int;
  126.           r_n_index_1:=r_n_index_1+1
  127.         END;
  128.       r_n_index_2:=7;
  129.       WHILE (r_n_index_1 > 0) DO
  130.         BEGIN
  131.           r_n_index_1:=r_n_index_1-1;
  132.           r_n[r_n_index_2]:=r_n[r_n_index_1];
  133.           r_n_index_2:=r_n_index_2-1
  134.         END;
  135.       WHILE (r_n_index_2 >= 0) DO
  136.         BEGIN
  137.           r_n[r_n_index_2]:=19;
  138.           r_n_index_2:=r_n_index_2-1
  139.         END;
  140.       magnitude_delta_x:=319 DIV num_columns DIV 2;
  141.       twice_magnitude_delta_x:=magnitude_delta_x+magnitude_delta_x;
  142.       magnitude_delta_y:=199 DIV num_rows DIV 2;
  143.       twice_magnitude_delta_y:=magnitude_delta_y+magnitude_delta_y;
  144.       x_max:=twice_magnitude_delta_x*num_columns;
  145.       y_max:=twice_magnitude_delta_y*num_rows;
  146.       delta_x[0][0]:=-magnitude_delta_x;
  147.       delta_y[1][0]:=magnitude_delta_y;
  148.       delta_x[2][0]:=magnitude_delta_x;
  149.       delta_y[3][0]:=-magnitude_delta_y;
  150.       delta_y[0][0]:=0;
  151.       delta_x[1][0]:=0;
  152.       delta_y[2][0]:=0;
  153.       delta_x[3][0]:=0;
  154.       delta_index_2:=-1;
  155.       FOR delta_index_1a:=0 TO 3 DO
  156.         FOR delta_index_1b:=0 TO 3 DO
  157.           IF delta_index_1a <> delta_index_1b THEN
  158.             FOR delta_index_1c:=0 TO 3 DO
  159.               IF ((delta_index_1a <> delta_index_1c)
  160.               AND (delta_index_1b <> delta_index_1c)) THEN 
  161.                 FOR delta_index_1d:=0 TO 3 DO
  162.                   IF ((delta_index_1a <> delta_index_1d)
  163.                   AND (delta_index_1b <> delta_index_1d)
  164.                   AND (delta_index_1c <> delta_index_1d)) THEN
  165.                     BEGIN
  166.                       delta_index_2:=delta_index_2+1;
  167.                       delta_x[delta_index_1a][delta_index_2]:=delta_x[0][0];
  168.                       delta_y[delta_index_1a][delta_index_2]:=delta_y[0][0];
  169.                       delta_x[delta_index_1b][delta_index_2]:=delta_x[1][0];
  170.                       delta_y[delta_index_1b][delta_index_2]:=delta_y[1][0];
  171.                       delta_x[delta_index_1c][delta_index_2]:=delta_x[2][0];
  172.                       delta_y[delta_index_1c][delta_index_2]:=delta_y[2][0];
  173.                       delta_x[delta_index_1d][delta_index_2]:=delta_x[3][0];
  174.                       delta_y[delta_index_1d][delta_index_2]:=delta_y[3][0]
  175.                     END
  176.     END;
  177.  
  178.   PROCEDURE draw_horizontal(x_1,x_2,y,color : INTEGER);
  179.     VAR
  180.       bank_offset  : INTEGER;
  181.       bank_segment : INTEGER;
  182.       byte_in_line : INTEGER;
  183.       byte_mask    : BYTE;
  184.       color_mask   : BYTE;
  185.       line_in_bank : INTEGER;
  186.       pixel_index  : INTEGER;
  187.       shift_index  : INTEGER;
  188.       x            : INTEGER;
  189.     BEGIN
  190.       line_in_bank:=y SHR 1;
  191.       IF y = line_in_bank+line_in_bank THEN
  192.         bank_segment:=$b800
  193.       ELSE
  194.         bank_segment:=$ba00;
  195.       byte_in_line:=x_1 SHR 2;
  196.       bank_offset:=80*line_in_bank;
  197.       bank_offset:=bank_offset+byte_in_line;
  198.       pixel_index:=x_1-(byte_in_line SHL 2);
  199.       byte_mask:=3;
  200.       color_mask:=color;
  201.       shift_index:=3-pixel_index;
  202.       WHILE (shift_index > 0) DO
  203.         BEGIN
  204.           color_mask:=color_mask SHL 2;
  205.           byte_mask:=byte_mask SHL 2;
  206.           shift_index:=shift_index-1
  207.         END;
  208.       byte_mask:=NOT byte_mask;
  209.       FOR x:=x_1 TO x_2 DO
  210.         BEGIN
  211.           Mem[bank_segment:bank_offset]
  212.            :=(Mem[bank_segment:bank_offset] AND byte_mask) OR color_mask;
  213.           pixel_index:=pixel_index+1;
  214.           IF pixel_index > 3 THEN
  215.             BEGIN
  216.               pixel_index:=0;
  217.               byte_mask:=$3f;
  218.               color_mask:=color;
  219.               color_mask:=color_mask SHL 6;
  220.               bank_offset:=bank_offset+1
  221.             END
  222.           ELSE
  223.             BEGIN
  224.               byte_mask:=NOT byte_mask;
  225.               byte_mask:=byte_mask SHR 2;
  226.               byte_mask:=NOT byte_mask;
  227.               color_mask:=color_mask SHR 2
  228.             END
  229.         END
  230.     END;
  231.  
  232.   PROCEDURE draw_vertical(x,y_1,y_2,color : INTEGER);
  233.     VAR
  234.       bank_1_offset  : INTEGER;
  235.       bank_1_segment : INTEGER;
  236.       bank_2_offset  : INTEGER;
  237.       bank_2_segment : INTEGER;
  238.       byte_in_line   : INTEGER;
  239.       byte_mask      : BYTE;
  240.       color_mask     : BYTE;
  241.       line_in_bank   : INTEGER;
  242.       offset         : INTEGER;
  243.       shift_index    : INTEGER;
  244.       tem_int        : INTEGER;
  245.       y              : INTEGER;
  246.     BEGIN
  247.       line_in_bank:=y_1 SHR 1;
  248.       IF y_1 = line_in_bank+line_in_bank THEN
  249.         BEGIN
  250.           bank_1_segment:=$b800;
  251.           bank_1_offset:=0;
  252.           bank_2_segment:=$ba00;
  253.           bank_2_offset:=0
  254.         END
  255.       ELSE
  256.         BEGIN
  257.           bank_1_segment:=$ba00;
  258.           bank_1_offset:=0;
  259.           bank_2_segment:=$b800;
  260.           bank_2_offset:=80
  261.         END;
  262.       byte_in_line:=x SHR 2;
  263.       offset:=80*line_in_bank;
  264.       offset:=offset+byte_in_line;
  265.       bank_1_offset:=bank_1_offset+offset;
  266.       bank_2_offset:=bank_2_offset+offset;
  267.       byte_mask:=$03;
  268.       color_mask:=color;
  269.       shift_index:=3;
  270.       shift_index:=shift_index-(x-(byte_in_line SHL 2));
  271.       WHILE (shift_index > 0) DO
  272.         BEGIN
  273.           color_mask:=color_mask SHL 2;
  274.           byte_mask:=byte_mask SHL 2;
  275.           shift_index:=shift_index-1
  276.         END;
  277.       byte_mask:=NOT byte_mask;
  278.       FOR y:=y_1 TO y_2 DO
  279.         BEGIN
  280.           Mem[bank_1_segment:bank_1_offset]
  281.            :=(Mem[bank_1_segment:bank_1_offset] AND byte_mask) OR color_mask;
  282.           tem_int:=bank_1_offset;
  283.           bank_1_offset:=bank_2_offset;
  284.           bank_2_offset:=tem_int+80;
  285.           tem_int:=bank_1_segment;
  286.           bank_1_segment:=bank_2_segment;
  287.           bank_2_segment:=tem_int
  288.         END
  289.     END;
  290.  
  291.   FUNCTION color(x,y : INTEGER) : INTEGER;
  292.     VAR
  293.       bank_offset  : INTEGER;
  294.       bank_segment : INTEGER;
  295.       byte_in_line : INTEGER;
  296.       line_in_bank : INTEGER;
  297.       byte_mask    : BYTE;
  298.       shift_index  : INTEGER;
  299.     BEGIN
  300.       line_in_bank:=y SHR 1;
  301.       IF y = line_in_bank+line_in_bank THEN
  302.         bank_segment:=$b800
  303.       ELSE
  304.         bank_segment:=$ba00;
  305.       byte_in_line:=x SHR 2;
  306.       bank_offset:=80*line_in_bank+byte_in_line;
  307.       shift_index:=x-(byte_in_line SHL 2);
  308.       IF shift_index < 2 THEN
  309.         IF shift_index = 0 THEN
  310.           color:=(Mem[bank_segment:bank_offset] AND $c0) SHR 6
  311.         ELSE
  312.           color:=(Mem[bank_segment:bank_offset] AND $30) SHR 4
  313.       ELSE
  314.         IF shift_index = 2 THEN
  315.           color:=(Mem[bank_segment:bank_offset] AND $0c) SHR 2
  316.         ELSE
  317.           color:=Mem[bank_segment:bank_offset] AND $03
  318.     END;
  319.  
  320.   PROCEDURE add_room;
  321.     VAR
  322.       delta_index_1 : BYTE;
  323.       delta_index_2 : BYTE;
  324.     BEGIN
  325.       y_out_max:=y+magnitude_delta_y-1;
  326.       FOR y_out:=y-magnitude_delta_y+1 TO y_out_max DO
  327.         draw_horizontal(x-magnitude_delta_x+1,x+magnitude_delta_x-1,y_out,
  328.          passage);
  329.       delta_index_1:=0;
  330.       REPEAT
  331.         delta_index_2:=r_n[0];
  332.         r_n_index_1:=0;
  333.         FOR r_n_index_2:=1 TO 7 DO
  334.           BEGIN
  335.             tem_int:=r_n[r_n_index_2];
  336.             r_n[r_n_index_1]:=tem_int;
  337.             r_n_index_1:=r_n_index_1+1;
  338.             delta_index_2:=delta_index_2+tem_int;
  339.             IF delta_index_2 >= 29 THEN
  340.               delta_index_2:=delta_index_2-29
  341.           END;
  342.         r_n[7]:=delta_index_2
  343.       UNTIL (delta_index_2 < 24);
  344.       WHILE (delta_index_1 <= 3) DO
  345.         BEGIN
  346.           x_next:=x+2*delta_x[delta_index_1][delta_index_2];
  347.           IF ((x_next <= 0) OR (x_next >= x_max)) THEN
  348.             delta_index_1:=delta_index_1+1
  349.           ELSE
  350.             BEGIN
  351.               y_next:=y+2*delta_y[delta_index_1][delta_index_2];
  352.               IF ((y_next <= 0) OR (y_next >= y_max)) THEN
  353.                 delta_index_1:=delta_index_1+1
  354.               ELSE
  355.                 IF color(x_next,y_next) = path THEN
  356.                   BEGIN
  357.                     IF x = x_next THEN
  358.                       draw_horizontal(x-magnitude_delta_x+1,
  359.                        x+magnitude_delta_x-1,(y+y_next) DIV 2,passage)
  360.                     ELSE
  361.                       draw_vertical((x+x_next) DIV 2,y-magnitude_delta_y+1,
  362.                        y+magnitude_delta_y-1,passage);
  363.                     x:=x_next;
  364.                     y:=y_next;
  365.                     add_room;
  366.                     x:=x-2*delta_x[delta_index_1][delta_index_2];
  367.                     y:=y-2*delta_y[delta_index_1][delta_index_2]
  368.                   END
  369.                 ELSE
  370.                   delta_index_1:=delta_index_1+1
  371.             END
  372.         END
  373.     END;
  374.  
  375.   PROCEDURE generate_maze;
  376.     VAR
  377.       tem_char     : BYTE;
  378.       video_offset : INTEGER;
  379.     BEGIN
  380.       GraphColorMode;
  381.       Palette(0);
  382.       tem_char:=path;
  383.       tem_char:=4*tem_char;
  384.       tem_char:=tem_char+path;
  385.       tem_char:=4*tem_char;
  386.       tem_char:=tem_char+path;
  387.       tem_char:=4*tem_char;
  388.       tem_char:=tem_char+path;
  389.       video_offset:=0;
  390.       FOR y_out:=1 TO 100 DO
  391.         FOR x_out:=1 TO 80 DO
  392.           BEGIN
  393.             Mem[$b800:video_offset]:=tem_char;
  394.             Mem[$ba00:video_offset]:=tem_char;
  395.             video_offset:=video_offset+1
  396.           END;
  397.       FOR y_out:=0 TO 199 DO
  398.         draw_horizontal(x_max+1,319,y_out,0);
  399.       FOR y_out:=y_max+1 TO 199 DO
  400.         draw_horizontal(0,319,y_out,0);
  401.       x_out:=0;
  402.       WHILE (x_out <= x_max) DO
  403.         BEGIN
  404.           draw_vertical(x_out,0,y_max,wall);
  405.           x_out:=x_out+twice_magnitude_delta_x
  406.         END;
  407.       y_out:=0;
  408.       WHILE (y_out <= y_max) DO
  409.         BEGIN
  410.           draw_horizontal(0,x_max,y_out,wall);
  411.           y_out:=y_out+twice_magnitude_delta_y
  412.         END;
  413.       IF ODD(num_columns) THEN
  414.         x:=num_columns*magnitude_delta_x
  415.       ELSE
  416.         x:=(num_columns-1)*magnitude_delta_x;
  417.       IF ODD(num_rows) THEN
  418.         y:=num_rows*magnitude_delta_y
  419.       ELSE
  420.         y:=(num_rows-1)*magnitude_delta_y;
  421.       add_room;
  422.       draw_horizontal(1,twice_magnitude_delta_x-1,0,passage);
  423.       draw_horizontal(x_max-twice_magnitude_delta_x+1,x_max,y_max,passage);
  424.       MOVE(screen,screen_image,16384);
  425.       SOUND(1000);
  426.       DELAY(333);
  427.       NOSOUND
  428.     END;
  429.  
  430.   PROCEDURE let_user_try_to_solve;
  431.     VAR
  432.       delta_index_1 : INTEGER;
  433.       frequency     : INTEGER;
  434.       passage_found : BOOLEAN;
  435.       tem_int       : INTEGER;
  436.     BEGIN
  437.       register.ah:=8;
  438.       x:=magnitude_delta_x;
  439.       y:=magnitude_delta_y;
  440.       y_next:=0;
  441.       draw_vertical(x,0,y,path);
  442.       REPEAT
  443.         REPEAT
  444.           passage_found:=TRUE;
  445.           Intr(33,register);
  446.           IF ((register.al <> 'Q')
  447.           AND (register.al <> 'q')
  448.           AND (register.al <> 'S')
  449.           AND (register.al <> 's')) THEN
  450.             BEGIN
  451.               IF register.al = #0 THEN
  452.                 BEGIN
  453.                   Intr(33,register);
  454.                   CASE register.al OF
  455.                     #72: delta_index_1:=3;
  456.                     #77: delta_index_1:=2;
  457.                     #80: delta_index_1:=1;
  458.                     #75: delta_index_1:=0;
  459.                     ELSE
  460.                       BEGIN
  461.                         passage_found:=FALSE;
  462.                         SOUND(120);
  463.                         DELAY(278);
  464.                         NOSOUND;
  465.                         register.al:=' '
  466.                       END
  467.                    END
  468.                 END
  469.               ELSE
  470.                 BEGIN
  471.                   CASE register.al OF
  472.                     #56: delta_index_1:=3;
  473.                     #54: delta_index_1:=2;
  474.                     #50: delta_index_1:=1;
  475.                     #52: delta_index_1:=0;
  476.                     ELSE
  477.                       BEGIN
  478.                         passage_found:=FALSE;
  479.                         SOUND(120);
  480.                         DELAY(278);
  481.                         NOSOUND
  482.                       END
  483.                     END
  484.                 END;
  485.               IF passage_found THEN
  486.                 BEGIN
  487.                   x_next:=x+delta_x[delta_index_1][0];
  488.                   y_next:=y+delta_y[delta_index_1][0];
  489.                   IF color(x_next,y_next) = wall THEN
  490.                     BEGIN
  491.                       passage_found:=FALSE;
  492.                       SOUND(120);
  493.                       DELAY(278);
  494.                       NOSOUND
  495.                     END
  496.                   ELSE
  497.                     BEGIN
  498.                       IF y_next = 0 THEN
  499.                         BEGIN
  500.                           passage_found:=FALSE;
  501.                           SOUND(120);
  502.                           DELAY(278);
  503.                           NOSOUND
  504.                         END
  505.                     END
  506.                 END
  507.             END
  508.         UNTIL ((passage_found)
  509.         OR     (register.al = 'Q')
  510.         OR     (register.al = 'q')
  511.         OR     (register.al = 'S')
  512.         OR     (register.al = 's'));
  513.         IF ((register.al <> 'Q')
  514.         AND (register.al <> 'q')
  515.         AND (register.al <> 'S')
  516.         AND (register.al <> 's')) THEN
  517.           BEGIN
  518.             x_next:=x_next+delta_x[delta_index_1][0];
  519.             y_next:=y_next+delta_y[delta_index_1][0];
  520.             IF y_next <= y_max THEN
  521.               BEGIN
  522.                 tem_int:=color(x_next,y_next);
  523.                 IF x = x_next THEN
  524.                   IF y < y_next THEN
  525.                     IF tem_int = path THEN
  526.                       draw_vertical(x,y,y_next,erase)
  527.                     ELSE
  528.                       draw_vertical(x,y,y_next,path)
  529.                   ELSE
  530.                     IF tem_int = path THEN
  531.                       draw_vertical(x,y_next,y,erase)
  532.                     ELSE
  533.                       draw_vertical(x,y_next,y,path)
  534.                 ELSE
  535.                   IF x < x_next THEN
  536.                     IF tem_int = path THEN
  537.                       draw_horizontal(x,x_next,y,erase)
  538.                     ELSE
  539.                       draw_horizontal(x,x_next,y,path)
  540.                   ELSE
  541.                     IF tem_int = path THEN
  542.                       draw_horizontal(x_next,x,y,erase)
  543.                     ELSE
  544.                       draw_horizontal(x_next,x,y,path);
  545.                 x:=x_next;
  546.                 y:=y_next
  547.               END
  548.           END
  549.       UNTIL ((y_next > y_max)
  550.       OR     (register.al = 'Q')
  551.       OR     (register.al = 'q')
  552.       OR     (register.al = 'S')
  553.       OR     (register.al = 's'));
  554.       IF y_next > y_max THEN
  555.         BEGIN
  556.           draw_vertical(x,y,y_max,path);
  557.           frequency:=10;
  558.           FOR delta_index_1:=1 TO 100 DO
  559.             BEGIN
  560.               SOUND(frequency);
  561.               DELAY(56);
  562.               NOSOUND;
  563.               frequency:=frequency+10
  564.             END;
  565.           REPEAT
  566.             Intr(33,register);
  567.             IF ((register.al <> 'Q')
  568.             AND (register.al <> 'q')
  569.             AND (register.al <> 'S')
  570.             AND (register.al <> 's')) THEN
  571.               BEGIN
  572.                 SOUND(120);
  573.                 DELAY(278);
  574.                 NOSOUND
  575.               END;
  576.             IF register.al = #0 THEN
  577.               BEGIN
  578.                 Intr(33,register);
  579.                 register.al:=' '
  580.               END
  581.           UNTIL ((register.al = 'Q')
  582.           OR     (register.al = 'q')
  583.           OR     (register.al = 'S')
  584.           OR     (register.al = 's'))
  585.         END
  586.       END;
  587.  
  588.   PROCEDURE try_adjacent_room;
  589.     VAR
  590.       delta_index_1 : BYTE;
  591.     BEGIN
  592.       delta_index_1:=0;
  593.       WHILE ((delta_index_1 <= 3) AND (y_next <= y_max)) DO
  594.         BEGIN
  595.           x_next:=x+delta_x[delta_index_1][0];
  596.           y_next:=y+delta_y[delta_index_1][0];
  597.           IF color(x_next,y_next) = passage THEN
  598.             BEGIN
  599.               x_next:=x_next+delta_x[delta_index_1][0];
  600.               y_next:=y_next+delta_y[delta_index_1][0];
  601.               IF y_next <= y_max THEN
  602.                 BEGIN
  603.                   IF x = x_next THEN
  604.                     IF y < y_next THEN
  605.                       draw_vertical(x,y,y_next,path)
  606.                     ELSE
  607.                       draw_vertical(x,y_next,y,path)
  608.                   ELSE
  609.                     IF x < x_next THEN
  610.                       draw_horizontal(x,x_next,y,path)
  611.                     ELSE
  612.                       draw_horizontal(x_next,x,y,path);
  613.                   x:=x_next;
  614.                   y:=y_next;
  615.                   try_adjacent_room
  616.                 END;
  617.               IF y_next <= y_max THEN
  618.                 BEGIN
  619.                   x_next:=x;
  620.                   y_next:=y;
  621.                   x:=x-2*delta_x[delta_index_1][0];
  622.                   y:=y-2*delta_y[delta_index_1][0];
  623.                   IF x = x_next THEN
  624.                     IF y < y_next THEN
  625.                       draw_vertical(x,y,y_next,passage)
  626.                     ELSE
  627.                       draw_vertical(x,y_next,y,passage)
  628.                   ELSE
  629.                     IF x < x_next THEN
  630.                       draw_horizontal(x,x_next,y,passage)
  631.                     ELSE
  632.                       draw_horizontal(x_next,x,y,passage);
  633.                   delta_index_1:=delta_index_1+1
  634.                 END
  635.             END
  636.           ELSE
  637.             delta_index_1:=delta_index_1+1
  638.         END
  639.     END;
  640.  
  641.   PROCEDURE optionally_have_computer_solve;
  642.     VAR
  643.       tem_int : INTEGER;
  644.     BEGIN
  645.       IF ((register.al = 'S') 
  646.       OR  (register.al = 's')) THEN
  647.         BEGIN
  648.           MOVE(screen_image,screen,16384);
  649.           x:=magnitude_delta_x;
  650.           y:=magnitude_delta_y;
  651.           y_next:=y+magnitude_delta_y;
  652.           draw_vertical(x,0,y,path);
  653.           try_adjacent_room;
  654.           draw_vertical(x,y,y_max,path);
  655.           SOUND(1000);
  656.           DELAY(333);
  657.           NOSOUND;
  658.           register.ah:=8;
  659.           Intr(33,register);
  660.           IF register.al = #0 THEN
  661.             Intr(33,register)
  662.         END
  663.     END;
  664.  
  665.   PROCEDURE terminate;
  666.     BEGIN
  667.       TextMode
  668.     END;
  669.  
  670.   BEGIN
  671.     initialize;
  672.     generate_maze;
  673.     let_user_try_to_solve;
  674.     optionally_have_computer_solve;
  675.     terminate
  676.   END.
  677. 
  678.